package com.yuncheng.spcyApi.utils;

import org.apache.commons.lang3.StringUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * @author hua
 */
public class HtmlSplitUtils {

    private static final Logger log = LoggerFactory.getLogger(HtmlSplitUtils.class);

    /** html 字符串分割  <p ...+ </p> 为一组进行分割为数组 */
    public static void main(String[] args) {
        String htmlContent = "<p style=\"...\">...</p>" +
                "<p style=\"...\">...</p>" +
                "<p style=\"...\">...</p>" +
                "<p style=\"...\">...</p>"; // 假设这是你的HTML内容

        String html = "<html>" +
                "<p style=\"text-indent:2em;\">" +
                "<strong>提取车间2主要生产设备有</strong>：" +
                "</p>" +
                "<p style=\"text-indent:2em;\">" +
                "<span style=\"display:none;\"></span>" +
                "<table border=\"1\">" +
                // ... 省略中间的table内容 ...
                "</table></p>" +
                "<p>&nbsp; &nbsp; &nbsp;<strong> 颗粒车间主要生产设备有：</strong></p>" +
                "</p>" +
                "<p>这是另一个段落</p>" +
                "</html>";

//        List<String> paragraphs = splitParagraphs(htmlContent);
        List<String> paragraphs = extractParagraphsPreservingTables(html);

        for (String paragraph : paragraphs) {
            System.out.println(paragraph);
        }
    }

    /**
     * 注意：上面的方法没有处理嵌套<p>标签、自闭合标签或属性中包含">"的情况
     * 对于实际应用，建议使用HTML解析库如Jsoup
     */
    public static List<String> splitParagraphs(String htmlContent) {
        List<String> paragraphs = new ArrayList<>();
        try {
            int startIndex = 0;

            while (startIndex < htmlContent.length()) {
                int endIndex = htmlContent.indexOf("</p>", startIndex);
                if (endIndex == -1) {
                    // 如果找不到结束标签，则可能是最后一个段落未闭合或输入不合法
                    paragraphs.add("<p>" + htmlContent + "</p>");
                    break;
                }

                // 提取<p>...</p>之间的内容，注意要跳过开始的<p>和结束的</p>
                String paragraph = htmlContent.substring(startIndex + 3, endIndex).trim();
                paragraphs.add("<p " + paragraph + "</p>");

                // 更新startIndex为下一个<p>标签的开始位置
                startIndex = endIndex + 4;
            }
        }catch (Exception e){
            log.error("解析html文本出错：{}", e.getMessage());

            return paragraphs;
        }

        return paragraphs;
    }

    public static List<String> extractParagraphsPreservingTables(String htmlContent) {
        List<String> paragraphs = new ArrayList<>();

        try {
            Document doc = Jsoup.parse(htmlContent);

            /** 版本1：这个会把table 全部统一放到最后，不好 */
            // 提取所有的 <p> 标签，但不包括 <table> 内的 <p>
            /*Elements paragraphsOutsideTables = doc.select("body > p:not(table p)");
            for (Element paragraph : paragraphsOutsideTables) {
                paragraphs.add("<p>&nbsp;&nbsp;&nbsp;&nbsp;" + paragraph.text() + "</p>");
            }

            // 单独处理 <table> 标签内的内容
            Elements tables = doc.select("table");
            for (Element table : tables) {
                // 这里简单地将整个 <table> 及其内容作为一个字符串添加到列表中
                // 你可以根据需要进一步处理这个字符串
                paragraphs.add(table.outerHtml());
            }*/

            /** 版本2 */
            // 遍历所有的 <p> 标签
            /*Elements paragraphsElements = doc.select("p");
            for (int i = 0; i < paragraphsElements.size(); i++) {
                Element paragraph = paragraphsElements.get(i);

                // 初始化段落字符串
//                StringBuilder paragraphContent = new StringBuilder("<p>&nbsp;&nbsp;&nbsp;&nbsp;" + paragraph.text() + "</p>");

                // 检查当前 <p> 标签之后是否紧跟着 <table>
                Element nextSibling = paragraph.nextElementSibling();
//                if (nextSibling != null && nextSibling.tagName().equals("table")) {
                while (nextSibling != null && "table".equals(nextSibling.tagName())) {
                    // 将 <table> 的内容添加到段落字符串中
                    // 注意：这里简单地将 <table> 的 HTML 添加到段落中，可能不是最佳实践
                    // 根据需要，你可能需要更复杂的处理来格式化或转换 <table> 内容
//                    paragraphContent.append(nextSibling.outerHtml());

                    // 可选：如果你不想在列表中再次包含这个 <table>，可以跳过它
                    // 但在这个例子中，我们假设你只想在段落中包含它一次
                    // 因此，我们不从列表中单独添加 <table>
                    // 移动到下一个兄弟元素，继续检查是否还有 <table>
//                    nextSibling = nextSibling.nextElementSibling();

                    // 跳过对下一个 <p> 的检查（如果下一个元素也是 <p> 的话）
                    // 因为我们已经将紧接着的 <table> 视为当前 <p> 的一部分
                    // 注意：这个逻辑可能需要根据实际的 HTML 结构进行调整
                    // 例如，如果 <table> 之后可能还有其他非 <p> 元素，你可能需要更复杂的逻辑
//                    i++; // 假设下一个元素已经被处理
                }

                // 将构建好的段落字符串添加到列表中
//                paragraphs.add(paragraphContent.toString());
            }*/

            /** 版本3 */
            // 遍历所有的p标签，但不包括在table内的p标签
            // 遍历所有的p标签，但不包括在table内的p标签
            Elements ps = doc.select("p");
//            int index = 0;
//            for (Element p : ps) {
            for (int i = 0; i < ps.size(); i++) {
                Element p = ps.get(i);

                // 检查p标签的下一个兄弟节点是否是table
                Element nextSibling = p.nextElementSibling();
                if (nextSibling != null && nextSibling.tagName().equals("table")) {
                    // 处理p和紧接着的table
                    paragraphs.add("<p>&nbsp;&nbsp;&nbsp;&nbsp;" + p.html() + "</p>");
                    paragraphs.add(nextSibling.outerHtml());
                    // 跳过这个table，因为它已经被处理
                    i++;
                }
                /*else if (StringUtils.isNotBlank(p.html())) {
                    // 如果没有紧接着的table，则只处理p
                    paragraphs.add("<p>&nbsp;&nbsp;&nbsp;&nbsp;" + p.html() + "</p>");
                }*/

                // 检查p标签的最近祖先是否是table
                if (!p.parents().stream().anyMatch(elem -> elem.tagName().equals("table"))) {
                    if (StringUtils.isNotBlank(p.html())) {
                        paragraphs.add("<p>&nbsp;&nbsp;&nbsp;&nbsp;" + p.html() + "</p>");
                    }
                }
                /*else {
                    Elements tables = doc.select("table");
                    int order = 0;
                    for (Element table : tables) {
                        // 这里简单地将整个 <table> 及其内容作为一个字符串添加到列表中
                        // 你可以根据需要进一步处理这个字符串
                        if (index == order) {
                            paragraphs.add(table.outerHtml());
                            index++;
                        }else {
                            order++;
                        }
                    }
                }*/
            }

        } catch (Exception e) {
            // 日志记录或其他错误处理
            log.error("解析html文本出错：{}", e.getMessage());
        }

        return paragraphs;
    }
}
